import type { IpcRendererEvent } from 'electron'


//@ts-ignore js文件会报any 类型错误
import elementFunc from './element.js'
//@ts-ignore js文件会报any 类型错误
import { mainFunc } from './main.js'
//@ts-ignore js文件会报any 类型错误
import { elementMainFunc } from './element_main.js'
import { tab } from '../common/tab'

const ipcRenderer = require('electron').ipcRenderer

let tran: any

/**
 * 创建并返回 Google Translate 控制器实例。
 * 暴露统一的控制方法与状态订阅，用于 Renderer UI 调用。
 * @returns 控制器实例（包含 ensureInit/translate/onStateChange 等方法）
 */
function createGTController() {
  const getGoogle = () => (window as any).google

  /**
   * 确保 google.translate.TranslateElement 已完成初始化。
   * - 首次调用会创建实例；后续调用直接返回已创建实例。
   * @param opts 可选配置（includedLanguages/pageLanguage/autoDisplay/disableAutoTranslation/key）
   * @returns TranslateElement 实例
   * @throws 当底层 google.translate 尚未就绪时抛出错误，请稍后重试
   */
  const ensureInit = (
    opts?: Partial<{
      includedLanguages: string
      pageLanguage: string
      autoDisplay: boolean
      disableAutoTranslation: boolean
      key: string
    }>
  ) => {
    if (!tran) {
      const google = getGoogle()
      if (!google || !google.translate || !google.translate.TranslateElement) {
        // element.js/main.js/element_main.js 初始化可能尚未完成
        // 让调用方稍后重试
        throw new Error('google.translate not ready yet')
      }
      tran = new google.translate.TranslateElement({
        includedLanguages: 'en,zh-CN',
        autoDisplay: false,
        disableAutoTranslation: true,
        key: 'AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw',

        ...(opts || {})
      })
    }
    return tran
  }

  /**
   * 获取底层 Iu（翻译会话控制器）实例。
   * @returns Iu 实例或 null（未就绪/不存在）
   */
  const getIu = () => {
    try {
      const t = ensureInit()
      return t?.H || null // dv 内部的 Iu 实例
    } catch {
      return null
    }
  }

  /**
   * 获取当前会话的 Cu（DOM 翻译执行器）实例。
   * @returns Cu 实例或 null
   */
  const getCu = () => {
    const iu = getIu()
    return iu && iu.l ? iu.l : null // 当前会话的 Cu 执行器
  }

  /**
   * 内部状态：
   * - translating：是否处于“正在翻译”中
   * - translated：是否已“翻译成功”（尚未还原）
   */
  const state = { translating: false, translated: false }

  const stateSubscribers: Array<
    (
      status: 'idle' | 'translating' | 'translated',
      stats?: { success: number; failure: number }
    ) => void
  > = []

  // 翻译请求统计（由 element_main.js 注入）：读取全局统计
  type GTStats = { success: number; failure: number }
  const getStats = (): GTStats => {
    const s = (window as any).__gtTranslateStats
    return {
      success: s && typeof s.sessionSuccess === 'number' ? s.sessionSuccess : 0,
      failure: s && typeof s.sessionFailure === 'number' ? s.sessionFailure : 0
    }
  }

  // 通知工具
  /**
   * 通知统一状态枚举。
   * @param status 当前状态：'idle' | 'translating' | 'translated'
   */
  const notifyState = (status: 'idle' | 'translating' | 'translated') => {
    const stats = getStats()
    stateSubscribers.forEach(fn => {
      try {
        fn(status, stats)
      } catch {}
    })
  }
  const notifyTranslating = (val: boolean) => {
    if (state.translating === val) return
    state.translating = val
    if (val) notifyState('translating')
  }
  const notifyTranslated = (val: boolean) => {
    if (state.translated === val) return
    state.translated = val
    if (val) notifyState('translated')
  }

  /**
   * 安装底层补丁：
   * - 包裹 Iu.Qd（翻译开始）→ 置 translating=true；如之前为 translated 则复位
   * - 包裹 Iu.xi（翻译收尾）→ translating=false、translated=true，并触发状态通知
   */
  let patchInstalled = false
  const ensurePatches = () => {
    const iu = getIu() as any
    if (!iu || patchInstalled) return

    // 包裹 Qd：翻译开始 + 包装 onProgress 捕获无法启动
    if (typeof iu.Qd === 'function') {
      const origQd = iu.Qd.bind(iu)
      iu.Qd = function (a: any, b: any, c: any, d: any, e: any) {
        try {
          // 重置本次翻译会话的统计计数
          ;(window as any).__gtTranslateStats = { sessionSuccess: 0, sessionFailure: 0 }
        } catch {}
        notifyTranslating(true)
        if (state.translated) notifyTranslated(false)
        return origQd(a, b, c, d, e)
      }
    }

    // 包裹 xi：翻译完成（不代表一定成功）
    if (typeof iu.xi === 'function') {
      const origXi = iu.xi.bind(iu)
      iu.xi = function (...args: any[]) {
        // 无论成功或失败，流程都走到这里；优先停止“正在翻译”
        notifyTranslating(false)

        notifyTranslated(true)

        return origXi(...args)
      }
    }

    /**
     * 获取当前推断的源语言/目标语言。
     * @returns 包含 sl（源语言）与 tl（目标语言）的对象
     */

    patchInstalled = true
  }

  /**
   * 是否已“翻译成功”（译文已应用且尚未还原）。
   * @returns 是否已处于已翻译状态
   */
  const isTranslatedSuccessfully = () => {
    ensurePatches()
    return state.translated
  }

  /**
   * 还原原文：调用底层 Iu.restore() 将 DOM 文本恢复到翻译前状态。
   * @returns 是否调用成功（未就绪或无 restore 方法时返回 false）
   */
  const restoreOriginal = () => {
    try {
      const iu = getIu() as any
      if (iu && typeof iu.restore === 'function') {
        iu.restore()
        // 还原后：译文状态失效，且不在翻译中
        notifyTranslated(false)
        notifyTranslating(false)
        notifyState('idle')
        return true
      }
    } catch {}
    return false
  }

  /**
   * 是否处于“正在翻译”中。
   * @returns 是否正在翻译
   */
  const isTranslating = () => {
    const iu = getIu()
    try {
      return !!(iu && typeof iu.aj === 'function' && iu.aj())
    } catch {
      return false
    }
  }

  /**
   * 获取当前推断的源/目标语言。
   * @returns 包含 sl（源语言）与 tl（目标语言）的对象
   */
  const getCurrentLanguages = () => {
    const cu = getCu()
    const gadget = tran?.l // Vu 简易控件
    const sl = (cu && typeof cu.eb === 'function' && cu.eb()) || ''
    const tl =
      (cu && typeof cu.ra === 'function' && cu.ra()) || (gadget && gadget.ra && gadget.ra()) || ''
    return { sl, tl }
  }
  /**
   * 启用/禁用翻译。
   * @param on 是否启用
   */

  const enable = (on: boolean) => {
    ensureInit()
    if (typeof tran.setEnabled === 'function') tran.setEnabled(!!on)
  }

  /**
   * 触发翻译（绕过 UI，直接调用 Iu）。
   * @param opts { tl: string; sl?: string } 或目标语言字符串
   * @returns 是否通过 Iu.Qd 成功发起
   */
  const translate = (opts: { sl?: string; tl: string } | string) => {
    const iu = getIu()
    ensureInit()
    const { sl, tl } = typeof opts === 'string' ? ({ tl: opts } as any) : opts

    // 选择源语言：优先参数，其次 html[lang]，否则空串按 auto
    const htmlLang = (document.documentElement.getAttribute('lang') || '').trim()
    const resolvedSl = sl || htmlLang || ''

    // onProgress 占位
    const onProgress = function () {
      /* noop */
    }
    try {
      if (iu && typeof iu.Qd === 'function') {
        // (sl, tl, onProgress, force, extra)
        iu.Qd(resolvedSl, tl, onProgress, false, undefined)
        return true
      }
    } catch (e) {
      console.warn('[GT] translate via Iu.Qd failed:', e)
    }
    const dv: any = tran
    if (dv && typeof dv.Oh === 'function') dv.Oh()
    return false
  }

  /**
   * 订阅统一状态变化。
   * @param cb 回调函数，接收状态：'translating' | 'translated' | 'idle'
   * @returns 取消订阅函数
   */
  const onStateChange = (
    cb: (
      status: 'translating' | 'translated' | 'idle',
      stats?: { success: number; failure: number }
    ) => void
  ) => {
    ensureInit()
    ensurePatches()
    stateSubscribers.push(cb)
    // 立即告知当前状态，便于初始化 UI
    try {
      cb(getStatus().status as any, getStats())
    } catch {}
    return () => {
      const i = stateSubscribers.indexOf(cb)
      if (i >= 0) stateSubscribers.splice(i, 1)
    }
  }

  /**
   * 状态总览：返回 UI 控制常用的关键状态。
   * - isTranslating: 是否正在翻译（运行中）
   * - translatedSuccessfully: 是否已成功翻译且尚未还原
   * - sl/tl: 当前推断的源/目标语言
   * @returns { isTranslating, translatedSuccessfully, status, sl, tl }
   */
  const getStatus = () => {
    ensurePatches()
    const { sl, tl } = getCurrentLanguages()
    const t = isTranslating()
    let status: 'idle' | 'translating' | 'translated'
    if (t) status = 'translating'
    else if (state.translated) status = 'translated'
    else status = 'idle'
    return {
      isTranslating: t,
      translatedSuccessfully: state.translated,
      status,
      sl,
      tl
    }
  }

  /**
   * 导出 API（供 UI 控制/调试使用）：
   * - ensureInit(opts?)：确保初始化 TranslateElement
   * - isTranslating()：是否正在翻译
   * - isTranslatedSuccessfully()：是否已翻译成功（尚未还原）
   * - restoreOriginal()：还原原文
   * - getCurrentLanguages()：获取当前 sl/tl
   * - getStatus()：状态总览（含 status: 'idle' | 'translating' | 'translated'）
   * - enable(on)：启用/禁用翻译
   * - translate(opts | tl)：直接触发翻译
   * - onStateChange(cb)：订阅“统一状态枚举”的实时变化（'translating'/'translated'/'idle'）
   */
  return {
    ensureInit,
    // 状态类
    isTranslating,
    isTranslatedSuccessfully,
    getStatus,
    // 事件订阅（仅保留统一状态）
    onStateChange,

    // 操作类
    translate,
    restoreOriginal,
    enable,
    // 信息类
    getCurrentLanguages
  }
}

const googleTranslate = createGTController()

window.addEventListener('DOMContentLoaded', () => {
  elementFunc()
  mainFunc()
  elementMainFunc()
  googleTranslate.onStateChange((status, stats) => {
    console.log('[GT] status change:', status, stats)
    if (status === 'translated' && stats && stats.failure > 0 && stats.success === 0) {

      // 翻译失败
      tab.translationState('failure')
    } else {
      tab.translationState(status)
    }
  })
})

/**
 * 翻译页面
 * */
ipcRenderer.on('translate-page', async (e: IpcRendererEvent, language: string) => {
  googleTranslate.ensureInit()
  // tran.showBanner()
  googleTranslate.translate({ tl: language })
})

/**
 * 还原页面
 * */
ipcRenderer.on('restore-original', async () => {
  googleTranslate.restoreOriginal()
})
